package com.yuntsg.ruiijn.paperana.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Author: gcr
 * @Date: 2023/9/2 19:47
 */
public class PublicUtils {

    /**
     * 归一化
     * <p>
     * 两个区间
     * 一个 1-100 第二个 65-90 已知在 第二个区间值是81 求 81 这个值在第一个区间是多少
     * 90 - 81(A)        100-x
     * ------   =   --------
     * 90 - 65(B)      100-1(C)
     * 就是最大值减去得分值 除以这个区间长度 等于 另一个区间最大值 减去x 除以区间长度
     *
     * @param sourceMax 原始区间最大值
     * @param sourceMin 原始区间最小值
     * @param toMax     目标最大值
     * @param toMin     目标最小值
     * @param exist     已知值
     * @return tox      目标区间所求值x
     */
    public static double forceUnifyScore(double sourceMax, double sourceMin, double toMax, double exist, double toMin) {
        double B = Math.abs(sourceMax - sourceMin);
        double A = Math.abs(sourceMax - exist);
        double C = Math.abs(toMax - toMin);
        double D = (A * C) / B;
        double res = PublicUtils.takeTwoDigits(Math.abs(toMax - D));
        return res;
    }

    /**
     * 归一化
     * <p>
     * 两个区间
     * 一个 1-100 第二个 65-90 已知在 第二个区间值是81 求 81 这个值在第一个区间是多少
     * 90 - 81(A)        100-x
     * ------   =   --------
     * 90 - 65(B)      100-1(C)
     * 就是最大值减去得分值 除以这个区间长度 等于 另一个区间最大值 减去x 除以区间长度
     *
     * @param sourceMax 原始区间最大值
     * @param sourceMin 原始区间最小值
     * @param toMax     目标最大值
     * @param toMin     目标最小值
     * @param exist     已知值
     * @return tox      目标区间所求值x
     */
    public static double forceUnifyScoreReal(double sourceMax, double sourceMin, double toMax, double exist, double toMin) {
        double B = Math.abs(sourceMax - sourceMin);
        double A = Math.abs(sourceMax - exist);
        double C = Math.abs(toMax - toMin);
        double D = (A * C) / B;
        double res = (Math.abs(toMax - D));
        return res;
    }


    // 对Map进行排序，此排序为最大的在前面，输入一个map，再返回一个排序后的新map，Integer, Integer类型，本排序增加了过滤功能，可以设置要前多少（len）个。
    public static Map<String, Integer> mapSortValueLen(Map<String, Integer> mapName, Integer len) {
        Map<String, Integer> result = new LinkedHashMap<>();
        mapName.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue()
                        .reversed()).limit(len).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        return result;
    }

    // 取小数点后2位
    public static double takeTwoDigits(double d) {
        if (Double.isNaN(d) || Double.isInfinite(d)) {
            return d;
        }
        BigDecimal bd = new BigDecimal(d);
        BigDecimal bd2 = bd.setScale(2, RoundingMode.HALF_UP);
        return Double.parseDouble(bd2.toString());
    }

    // 取小数点后4位
    public static double takeFourDigits(double d) {
        BigDecimal bd = new BigDecimal(d);
        BigDecimal bd2 = bd.setScale(4, RoundingMode.HALF_UP);
        return Double.parseDouble(bd2.toString());
    }
}
